package main

import (
	"bytes"
	"fmt"
)

func functionB() {
	bSemComment1 := []byte("Hello")
	bSemComment2 := []byte{'H', 'e', 'l', 'l', 'o'}
	bSemComment3 := string([]byte{72, 101, 108, 108, 111})
	fmt.Println("bSemComment1:", bSemComment1, "length1:", len(bSemComment1))
	fmt.Println("bSemComment2:", bSemComment2, "length2:", len(bSemComment2))
	fmt.Println("bSemComment3:", bSemComment3, "length3:", len(bSemComment3))
}

func functionA() {
	// 这里不能写成 b := []byte{"Golang"}，这里是利用类型转换。
	b := []byte("Golang")
	subslice1 := []byte("go")
	subslice2 := []byte("Go")
	fmt.Printf("\n Contains 函数的用法\n")
	//func Contains(b, subslice [] byte) bool  检查字节切片 b ，是否包含子字节切片 subslice
	fmt.Println(bytes.Contains(b, subslice1)) //false
	fmt.Println(bytes.Contains(b, subslice2)) //true

	s := []byte("banana")
	sep1 := []byte("ban")
	sep2 := []byte("na")
	sep3 := []byte("a")
	fmt.Printf("\n Count 函数的用法\n")
	//func Count(s, sep []byte) int 计算子字节切片 sep 在字节切片 s 中出现的非重叠实例的数量。
	fmt.Println(bytes.Count(s, sep1))       //1
	fmt.Println(bytes.Count(s, sep2))       //2
	fmt.Println(bytes.Count(s, sep3))       //3
	fmt.Println(bytes.Count(s, []byte(""))) //7

	fmt.Printf("\n Map 函数的用法\n")
	//func Map(mapping func(r rune) rune, s []byte) []byte
	//Map函数：首先将 s 转化为 UTF-8编码的字符序列，然后使用 mapping 将每个Unicode字符映射为对应的字符，最后将结果保存在一个新的字节切片中
	s = []byte("同学们，上午好")
	f := func(r rune) rune {
		if r == '上' {
			//r = '下'
			r = 2
			r = -1 //如果mapping返回一个负值，将会丢弃该码值而不会被替换（返回值中对应位置将没有码值）。
		}
		return r
	}
	fmt.Println(string(s))               //同学们，上午好
	fmt.Println(string(bytes.Map(f, s))) //同学们，下午好

	fmt.Printf("\n Replace 函数的用法\n")
	//func Replace(s, old, new []byte, n int) []byte
	//返回字节切片 S 的一个副本， 并且将前n个不重叠的子切片 old 替换为 new，如果n < 0 那么不限制替换的数量
	s = []byte("google")
	old := []byte("o")
	//这里 new 是一个字节切片，不是关键字了
	new := []byte("oo")
	fmt.Println(string(bytes.Replace(s, old, new, 1)))         //gooogle
	fmt.Println(string(bytes.Replace(s, old, new, -1)))        //goooogle
	fmt.Println(string(bytes.Replace(s, []byte(""), new, -1))) //oogoooooooogoolooeoo

	fmt.Printf("\n Replace 函数的用法\n")
	//每个 rune 变量占据 4个字节，等价于 int32
	//每个 byte 变量占据1个字节，等价于int8
	s = []byte("中华人民共和国")
	r := bytes.Runes(s)
	fmt.Println(string(s), len(s)) //字节切片的长度 21
	fmt.Println(string(r), len(r)) // rune 切片的长度 7

	fmt.Printf("\n Join 函数的用法\n")
	ss := [][]byte{
		[]byte("你好"),
		[]byte("世界"), //这里的逗号，必不可少
	}
	sep := []byte(",")
	fmt.Println(string(bytes.Join(ss, sep))) //你好,世界

	fmt.Printf("\n 字节切片比较函数(Compare,Equal,EqualFold)的用法\n")
	com1 := []byte("abc")
	com2 := []byte("ABC")
	fmt.Println(bytes.Compare(com1, com2))
	fmt.Println(bytes.Equal(com1, com2))
	fmt.Println(bytes.EqualFold(com1, com2))

	fmt.Printf("\n Fields 函数的用法\n")
	//func Fields(s []byte) [][]byte
	//将字节切片 s 按照 一个或者连续多个空白字符 分割成 多个字节切片。如果 s 只包含空白字符，则返回 空字节切片。
	sss := []byte("I'm a student.")
	for _, f := range bytes.Fields(sss) {
		fmt.Printf("%q\n", f)
	}
	//	"I'm"
	//	"a"
	//	"student."
	s2 := []byte("   ")
	fmt.Println(len(s2), s2 == nil) // 3 false
}
func main() {
	functionB()
}
